package cn.ocars.playgame.pencilstudy.ui.components

import android.graphics.Path
import androidx.compose.ui.graphics.Color

/**
 * 书写字符数据结构
 */
data class WritingCharacterData(
    val character: String,
    val strokes: List<StrokeInfo>,
    val displayHint: String? = null,
    val characterType: CharacterType? = null
) {
    /**
     * 获取总笔画数
     */
    fun getTotalStrokes(): Int = strokes.size
    
    /**
     * 获取指定笔画的路径
     */
    fun getStrokePath(index: Int): Path? {
        return if (index in strokes.indices) strokes[index].path else null
    }
    
    /**
     * 获取所有笔画路径
     */
    fun getAllStrokePaths(): List<Path> = strokes.map { it.path }
}

/**
 * 笔画信息
 */
data class StrokeInfo(
    val path: Path,
    val strokeType: StrokeType = StrokeType.NORMAL,
    val order: Int,
    val description: String? = null
)

/**
 * 字符类型枚举
 */
enum class CharacterType {
    DIGIT,      // 数字 0-9
    LETTER,     // 字母 A-Z, a-z
    CHINESE,    // 汉字
    STROKE,     // 基本笔画
    RADICAL     // 偏旁部首
}

/**
 * 笔画类型枚举
 */
enum class StrokeType {
    HORIZONTAL,  // 横
    VERTICAL,    // 竖
    LEFT_FALLING, // 撇
    RIGHT_FALLING, // 捺
    DOT,         // 点
    HOOK,        // 钩
    TURN,        // 折
    NORMAL       // 普通笔画
}

/**
 * 预定义字符数据
 */
object CharacterDataProvider {
    
    /**
     * 创建数字"1"的字符数据（田字格坐标系：0.0-1.0，中心为0.5,0.5）
     */
    fun createNumber1(): WritingCharacterData {
        val strokes = mutableListOf<StrokeInfo>()
        
        // 数字1只有一笔：竖（在田字格中央）
        val path1 = Path().apply {
            moveTo(0.5f, 0.3f)  // 上方
            lineTo(0.5f, 0.7f)  // 下方
        }
        strokes.add(StrokeInfo(path1, StrokeType.VERTICAL, 1, "竖"))
        
        return WritingCharacterData("1", strokes, "数字一", CharacterType.DIGIT)
    }
    
    /**
     * 创建汉字"一"的字符数据
     */
    fun createCharacterYi(): WritingCharacterData {
        val strokes = mutableListOf<StrokeInfo>()
        
        // 汉字"一"只有一笔：横（在田字格中央）
        val path1 = Path().apply {
            moveTo(0.3f, 0.5f)  // 左侧
            lineTo(0.7f, 0.5f)  // 右侧
        }
        strokes.add(StrokeInfo(path1, StrokeType.HORIZONTAL, 1, "横"))
        
        return WritingCharacterData("一", strokes, "汉字一", CharacterType.CHINESE)
    }
    
    /**
     * 创建汉字"人"的字符数据
     */
    fun createCharacterRen(): WritingCharacterData {
        val strokes = mutableListOf<StrokeInfo>()
        
        // 第一笔：撇（从中上到左下）
        val path1 = Path().apply {
            moveTo(0.5f, 0.3f)  // 中上
            lineTo(0.35f, 0.7f) // 左下
        }
        strokes.add(StrokeInfo(path1, StrokeType.LEFT_FALLING, 1, "撇"))
        
        // 第二笔：捺（从中上到右下）
        val path2 = Path().apply {
            moveTo(0.5f, 0.3f)  // 中上
            lineTo(0.65f, 0.7f) // 右下
        }
        strokes.add(StrokeInfo(path2, StrokeType.RIGHT_FALLING, 2, "捺"))
        
        return WritingCharacterData("人", strokes, "汉字人", CharacterType.CHINESE)
    }
    
    /**
     * 创建汉字"大"的字符数据
     */
    fun createCharacterDa(): WritingCharacterData {
        val strokes = mutableListOf<StrokeInfo>()
        
        // 第一笔：横（在上方）
        val path1 = Path().apply {
            moveTo(0.35f, 0.35f) // 左上
            lineTo(0.65f, 0.35f) // 右上
        }
        strokes.add(StrokeInfo(path1, StrokeType.HORIZONTAL, 1, "横"))
        
        // 第二笔：撇（从横的中点到左下）
        val path2 = Path().apply {
            moveTo(0.5f, 0.35f)  // 横的中点
            lineTo(0.3f, 0.7f)   // 左下
        }
        strokes.add(StrokeInfo(path2, StrokeType.LEFT_FALLING, 2, "撇"))
        
        // 第三笔：捺（从横的中点到右下）
        val path3 = Path().apply {
            moveTo(0.5f, 0.35f)  // 横的中点
            lineTo(0.7f, 0.7f)   // 右下
        }
        strokes.add(StrokeInfo(path3, StrokeType.RIGHT_FALLING, 3, "捺"))
        
        return WritingCharacterData("大", strokes, "汉字大", CharacterType.CHINESE)
    }
    
    /**
     * 创建数字"0"的字符数据
     */
    fun createNumber0(): WritingCharacterData {
        val strokes = mutableListOf<StrokeInfo>()
        
        // 数字0：椭圆形
        val path1 = Path().apply {
            addOval(0.35f, 0.3f, 0.65f, 0.7f, Path.Direction.CW)
        }
        strokes.add(StrokeInfo(path1, StrokeType.NORMAL, 1, "椭圆"))
        
        return WritingCharacterData("0", strokes, "数字零", CharacterType.DIGIT)
    }
    
    /**
     * 创建数字"2"的字符数据
     */
    fun createNumber2(): WritingCharacterData {
        val strokes = mutableListOf<StrokeInfo>()
        
        // 数字2：上弧线 + 下横线
        val path1 = Path().apply {
            moveTo(0.35f, 0.4f)
            quadTo(0.5f, 0.25f, 0.65f, 0.4f)
            lineTo(0.35f, 0.65f)
            lineTo(0.65f, 0.65f)
        }
        strokes.add(StrokeInfo(path1, StrokeType.NORMAL, 1, "2字形"))
        
        return WritingCharacterData("2", strokes, "数字二", CharacterType.DIGIT)
    }
    
    /**
     * 创建字母"A"的字符数据
     */
    fun createLetterA(): WritingCharacterData {
        val strokes = mutableListOf<StrokeInfo>()
        
        // 第一笔：左斜线
        val path1 = Path().apply {
            moveTo(0.5f, 0.3f)  // 顶点
            lineTo(0.35f, 0.7f) // 左下
        }
        strokes.add(StrokeInfo(path1, StrokeType.LEFT_FALLING, 1, "左斜线"))
        
        // 第二笔：右斜线
        val path2 = Path().apply {
            moveTo(0.5f, 0.3f)  // 顶点
            lineTo(0.65f, 0.7f) // 右下
        }
        strokes.add(StrokeInfo(path2, StrokeType.RIGHT_FALLING, 2, "右斜线"))
        
        // 第三笔：横线
        val path3 = Path().apply {
            moveTo(0.4f, 0.5f)  // 左中
            lineTo(0.6f, 0.5f)  // 右中
        }
        strokes.add(StrokeInfo(path3, StrokeType.HORIZONTAL, 3, "横线"))
        
        return WritingCharacterData("A", strokes, "字母A", CharacterType.LETTER)
    }
    
    /**
     * 创建字母"O"的字符数据
     */
    fun createLetterO(): WritingCharacterData {
        val strokes = mutableListOf<StrokeInfo>()
        
        // 字母O：圆形
        val path1 = Path().apply {
            addOval(0.35f, 0.3f, 0.65f, 0.7f, Path.Direction.CW)
        }
        strokes.add(StrokeInfo(path1, StrokeType.NORMAL, 1, "圆形"))
        
        return WritingCharacterData("O", strokes, "字母O", CharacterType.LETTER)
    }
    
    /**
     * 创建基本笔画"横"的字符数据
     */
    fun createStrokeHeng(): WritingCharacterData {
        val strokes = mutableListOf<StrokeInfo>()
        
        val path1 = Path().apply {
            moveTo(0.25f, 0.5f)  // 左侧
            lineTo(0.75f, 0.5f)  // 右侧
        }
        strokes.add(StrokeInfo(path1, StrokeType.HORIZONTAL, 1, "横"))
        
        return WritingCharacterData("横", strokes, "基本笔画横", CharacterType.STROKE)
    }
    
    /**
     * 创建基本笔画"竖"的字符数据
     */
    fun createStrokeShu(): WritingCharacterData {
        val strokes = mutableListOf<StrokeInfo>()
        
        val path1 = Path().apply {
            moveTo(0.5f, 0.25f)  // 上方
            lineTo(0.5f, 0.75f)  // 下方
        }
        strokes.add(StrokeInfo(path1, StrokeType.VERTICAL, 1, "竖"))
        
        return WritingCharacterData("竖", strokes, "基本笔画竖", CharacterType.STROKE)
    }
    
    /**
     * 根据字符获取对应的字符数据
     */
    fun getCharacterData(character: String): WritingCharacterData? {
        return when (character) {
            // 数字
            "0" -> createNumber0()
            "1" -> createNumber1()
            "2" -> createNumber2()
            // 字母
            "A" -> createLetterA()
            "O" -> createLetterO()
            // 汉字
            "一" -> createCharacterYi()
            "人" -> createCharacterRen()
            "大" -> createCharacterDa()
            // 基本笔画
            "横" -> createStrokeHeng()
            "竖" -> createStrokeShu()
            else -> null
        }
    }
    
    /**
     * 获取所有支持的字符列表
     */
    fun getSupportedCharacters(): List<String> {
        return listOf(
            "0", "1", "2",           // 数字
            "A", "O",                // 字母
            "一", "人", "大",         // 汉字
            "横", "竖"               // 基本笔画
        )
    }
}